public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;

    private transient HashMap<E,Object> map;

Map m = Collections.synchronizedMap（new HashMap（...））

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
{
	/**
     * The default initial capacity - MUST be a power of two.
     * 默认的初始化容量，必须为2的幂，为什么呢，先mark一下[这里用了位移运算，初始化为16]
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    
    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     * 如果具有参数的任一构造函数隐式指定较高值，则使用最大容量，必须为2的幂且<=1<<30
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;
    
    /**
     * An empty table instance to share when the table is not inflated.
     */
    static final Entry<?,?>[] EMPTY_TABLE = {};
    
    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
    
    /**
     * The number of key-value mappings contained in this map.
     * 容量
     */
    transient int size;
    
    /**
     * The next size value at which to resize (capacity * load factor).
     * @serial
     * 容量*负载因子 储存的元素到达这个数字的时候进行扩容【阈值】
     */
    // If table == EMPTY_TABLE then this is the initial capacity at which the
    // table will be created when inflated.
    int threshold;
    
    /**
     * The load factor for the hash table.
     * 负载因子
     * @serial
     */
    final float loadFactor;
    
    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     * 这个字段已经见过很多次了，记录HashMap修改次数的
     */
    transient int modCount;
    
    /**
     * 默认的阈值
     */
    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
    
    /**
     * 这个不知道是干嘛的，暂时先放着
     */
    transient int hashSeed = 0;
    
    /**
     * 这个静态内部类也不知道是干嘛的
     */
    private static class Holder {

        /**
         * Table capacity above which to switch to use alternative hashing.
         */
        static final int ALTERNATIVE_HASHING_THRESHOLD;

        static {
            String altThreshold = java.security.AccessController.doPrivileged(
                new sun.security.action.GetPropertyAction(
                    "jdk.map.althashing.threshold"));

            int threshold;
            try {
                threshold = (null != altThreshold)
                        ? Integer.parseInt(altThreshold)
                        : ALTERNATIVE_HASHING_THRESHOLD_DEFAULT;

                // disable alternative hashing if -1
                if (threshold == -1) {
                    threshold = Integer.MAX_VALUE;
                }

                if (threshold < 0) {
                    throw new IllegalArgumentException("value must be positive integer.");
                }
            } catch(IllegalArgumentException failed) {
                throw new Error("Illegal value for 'jdk.map.althashing.threshold'", failed);
            }

            ALTERNATIVE_HASHING_THRESHOLD = threshold;
        }
    }
    /**
     * 上面出现了Entry，这个内部类是HashMap中存储数据的静态内部类
     * 上面的属性中定义了一个Entry类型的数组，
     * Entry类中又保存了下一个Entry的引用[Entry<K,V> next]
     * 我们熟悉的HashMap是才用数组+链表的方式存储数据的雏形就出来了
     */
     
     static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
       }

/**
 * 带初始容量和负载因子的构造方法
 */
public HashMap(int initialCapacity, float loadFactor) {
    //检查参数边界
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);

    //初始化负载因子和阈值
    this.loadFactor = loadFactor;
    threshold = initialCapacity;
    init();
}